﻿// Autore: Mattia Barrasso

using System.Linq;
using NUnit.Framework;
using RecipesManager.Data;
using TechTalk.SpecFlow;
using White.Core.Factory;

namespace RecipesManager.Specs.Ospite
{
    [Binding, Scope(Feature = "AggiungiOspite")]
    public class AggiungiOspite_Steps : OspiteBdd
    {
        [BeforeScenario]
        public new void SetUpScenario()
        {
            base.SetUpScenario();
        }

        [AfterScenario]
        public new void TearDownScenario()
        {
            base.TearDownScenario();
        }

        [AfterStep]
        [BeforeStep]
        public void MiniStop()
        {
            MainWindow.WaitWhileBusy();
            MainWindow.ReloadIfCached();
            MainWindow.ReInitialize(InitializeOption.NoCache);
        }

        [Given(Regex = "l'ospite \"([a-zA-Z ]+)\" esiste")]
        public void DatoEsisteOspite(string ospite)
        {
            Manager.Guests.Add(ospite);
        }

        [Given(Regex = "l'ospite \"([a-zA-Z ]+)\" non esiste")]
        public void DatoNonEsisteOspite(string ospite)
        {
            Assert.That(!Manager.Guests.Contains(ospite));
        }

        [Given(Regex = "l'ingrediente \"([a-zA-Z ]+)\" esiste")]
        public void DatoIngredienteEsistente(string ingrediente)
        {
            Manager.Ingredients.Add(ingrediente, MeasureType.Weight);
        }

        [Given(Regex = "la categoria \"([a-zA-Z ]+)\" esiste")]
        public void DataCategoriaEsistente(string categoria)
        {
            Manager.Categories.Add(categoria);
        }

        [Given(Regex = "l'ingrediente \"([a-zA-Z ]+)\" appartiene alla categoria \"([a-zA-Z ]+)\"")]
        public void DatoIngredienteAppartenenteCategoria(string ingrediente, string categoria)
        {
            Manager.Ingredients[ingrediente].Categories.Add(categoria);
        }

        [Given(Regex = "ho inserito i valori")]
        public void DatoInseritoValori(Table table)
        {
            NavigateToGuests();
            GetGuestsUi();
            NewGuest.Click();
            GetSingleGuestUi();

            foreach (var tableRow in table.Rows)
            {
                if(tableRow["Attributi"].Equals("Nome"))
                {
                    GuestName.SetValue(tableRow["Valori"]);
                }else if(tableRow["Attributi"].Equals("Nota"))
                {
                    GuestNote.SetValue(tableRow["Valori"]);
                }else
                {
                    Assert.Fail("Table");
                }
            }
        }

        [Given(Regex = "ho inserito una preferenza per l'ingrediente \"([a-zA-Z ]+)\", valore ([0-9]+)")]
        [Given(Regex = "ho inserito una preferenza per la categoria \"([a-zA-Z ]+)\", valore ([0-9]+)")]
        public void DataPreferenzaCibo(string cibo, int valore)
        {
            //MainWindow.ReInitialize(InitializeOption.NoCache);
            //Thread.Sleep(1500);
            if(CercaCiboPreferito(cibo) == -1)
            {
                //Assert.That(FoodPreferences.Items.Any(item => item.Text.Equals(cibo)));
                FoodPreferences.Click();
                FoodPreferences.SetValue(cibo);
                //FoodPreferences.Select(cibo);
                AddFoodPreference.Click();
            }else
            {
                Assert.That(!FoodPreferences.Items.Exists(item => item.Text.Equals(cibo)));
            }
            var index = -1;
            if (valore == 2)
            {
                index = 0;
            }
            else
            {
                Assert.Fail("Values");
            }
            ModificaPreferenzaCibo(cibo, index);
        }

        [Given(Regex = "ho inserito un'intolleranza per l'ingrediente \"([a-zA-Z ]+)\"")]
        [Given(Regex = "ho inserito un'intolleranza per la categoria \"([a-zA-Z ]+)\"")]
        public void DataIntolleranzaCibo(string cibo)
        {
            if (CercaCiboPreferito(cibo) == -1)
            {
                //MainWindow.ReInitialize(InitializeOption.NoCache);
                FoodPreferences.Click();
                FoodPreferences.SetValue(cibo);
                AddFoodPreference.Click();
            }
            else
            {
                Assert.That(!FoodPreferences.Items.Exists(item => item.Text.Equals(cibo)));
            }
            ImpostaCiboComeNonTollerato(cibo);
        }

        [Given(Regex = "inserisco la preferenza verso \"([a-zA-Z ]+)\", valore ([0-9]+)")]
        public void DataPreferenzaPersona(string ospitePreferito, int valore)
        {
            if (CercaPersonaPreferita(ospitePreferito) == -1)
            {
                //Assert.That(GuestsPreferences.Items.Exists(item => item.Text.Equals(ospitePreferito)));
                GuestsPreferences.Click();
                GuestsPreferences.Select(ospitePreferito);
                AddGuestPreference.Click();
            }
            else
            {
                Assert.That(!GuestsPreferences.Items.Exists(item => item.Text.Equals(ospitePreferito)));
            }
            var index = -1;
            if(valore == 2)
            {
                index = 0;
            }else
            {
                Assert.Fail("Values");
            }
            ModificaPreferenzaPersona(ospitePreferito, index);
        }

        [Given(Regex = "inserisco una relazione con \"([a-zA-Z ]+)\"")]
        public void DataRelazionePersona(string ospiteRelazione)
        {
            if(CercaPersonaPreferita(ospiteRelazione) == -1)
            {
                //Assert.That(GuestsPreferences.Items.Exists(item => item.Text.Equals(ospiteRelazione)));
                GuestsPreferences.Click();
                GuestsPreferences.Select(ospiteRelazione);
                AddGuestPreference.Click();
            }else
            {
                Assert.That(!GuestsPreferences.Items.Exists(item => item.Text.Equals(ospiteRelazione)));
            }
            ImpostaPersonaComeIndispensabile(ospiteRelazione);
        }

        [When(Regex = "salvo")]
        public void QuandoSalvo()
        {
            Assert.That(Save.Enabled);
            Save.Click();
        }

        [Then(Regex = "l'operazione ha successo")]
        public void AlloraSuccesso()
        {
            Assert.That(!MainWindow.ModalWindows().Any());
        }

        [Then(Regex = "l'operazione non ha successo")]
        public void AlloraInsuccesso()
        {
            Assert.That(MainWindow.ModalWindows().Count == 1);
        }

        [Then(Regex = "esiste l'ospite \"([a-zA-Z ]+)\"")]
        public void AlloraEsisteOspite(string ospite)
        {
            Assert.That(Guests.Items.Exists(item => item.Text.Equals(ospite)));
            Assert.That(Manager.Guests.Contains(ospite));
        }

        [Then(Regex = "non esiste l'ospite \"([a-zA-Z ]+)\"")]
        public void AlloraNonEsisteOspite(string ospite)
        {
            Assert.That(Guests.Items.Exists(item => item.Text.Equals(ospite)));
            Assert.That(Manager.Guests.Contains(ospite));
        }

        [Then(Regex = "l'ospite \"([a-zA-Z ]+)\" ha una preferenza di valore ([0-9]+) con \"([a-zA-Z ]+)\"")]
        public void AlloraOspiteHaPreferenza(string ospite,  int valore, string ospitePreferito)
        {
            var guestRating = GuestRating.VeryGood;
            if(valore == 2)
            {
                guestRating = GuestRating.VeryGood;
            }else
            {
                Assert.Fail("Guest Rating");
            }
            Assert.That(Manager.Guests[ospite].GuestRatings.Contains(ospitePreferito));
            Assert.That(Manager.Guests[ospite].GuestRatings[ospitePreferito].Rating == guestRating);
        }

        [Then(Regex = "l'ospite \"([a-zA-Z ]+)\" ha una preferenza per l'ingrediente \"([a-zA-Z ]+)\", valore ([0-9]+)")]
        public void AlloraOspitePreferisceIngrediente(string ospite, string ingrediente, int valore)
        {
            var foodRating = FoodRating.VeryGood;
            if (valore == 2)
            {
                foodRating = FoodRating.VeryGood;
            }
            else
            {
                Assert.Fail("Guest Rating");
            }
            Assert.That(Manager.Guests[ospite].IngredientRatings.Contains(ingrediente));
            Assert.That(Manager.Guests[ospite].IngredientRatings[ingrediente].Rating == foodRating);
        }

        [Then(Regex = "l'ospite \"([a-zA-Z ]+)\" ha una preferenza per la categoria \"([a-zA-Z ]+)\", valore ([0-9]+)")]
        public void AlloraOspitePreferisceCategoria(string ospite, string categoria, int valore)
        {
            var foodRating = FoodRating.VeryGood;
            if (valore == 2)
            {
                foodRating = FoodRating.VeryGood;
            }
            else
            {
                Assert.Fail("Guest Rating");
            }
            Assert.That(Manager.Guests[ospite].CategoryRatings.Contains(categoria));
            Assert.That(Manager.Guests[ospite].CategoryRatings[categoria].Rating == foodRating);
        }

        [Then(Regex = "l'ospite \"([a-zA-Z ]+)\" ha un'intolleranza per la categoria \"([a-zA-Z ]+)\"")]
        public void AlloraOspiteIntolleranteCategoria(string ospite, string categoria)
        {
            Assert.That(Manager.Guests[ospite].CategoryIntolerances.Contains(categoria));
        }

        [Then(Regex = "l'ospite \"([a-zA-Z ]+)\" ha un'intolleranza per l'ingrediente \"([a-zA-Z ]+)\"")]
        public void AlloraOspiteIntolleranteIngrediente(string ospite, string ingrediente)
        {
            Assert.That(Manager.Guests[ospite].IngredientIntolerances.Contains(ingrediente));
        }

        [Then(Regex = "l'ospite \"([a-zA-Z ]+)\" non ha preferenze verso \"([a-zA-Z ]+)\"")]
        public void AlloraOspiteNonHaPreferenze(string ospite, string ospitePreferito)
        {
            Assert.That(!Manager.Guests[ospite].GuestRatings.Contains(ospitePreferito));
        }

        [Then(Regex = "l'ospite \"([a-zA-Z ]+)\" ha una relazione con \"([a-zA-Z ]+)\"")]
        public void AlloraOspiteHaRelazione(string ospite, string ospiteInRelazione)
        {
            Assert.That(Manager.Guests[ospite].GuestRelationships.Contains(ospiteInRelazione));
        }
    }
}
